home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / dskut / reform15.zip / REFORMAT.IN1 < prev    next >
Text File  |  1987-05-23  |  6KB  |  206 lines
  1. {REFORMAT IN1}
  2. {
  3.   Unsigned word arithmetic routines.
  4.   Just to have the source of the program clean, and free of dirty tricks.
  5.   Some of the functions provided here are redundant, e.g. the shift
  6.   functions, since TURBO's shift functions are logical shifts, rather
  7.   than arithmetic shifts.
  8.  
  9.   Functions:
  10.         W_not(W1     : word): word;              bitwise logical not
  11.         W_add(W1, W2 : word): word;              addition
  12.         W_sub(W1, W2 : word): word;              subtraction
  13.         W_or (W1, W2 : word): word;              bitwise logical or
  14.         W_xor(W1, W2 : word): word;              bitwise logical xor
  15.         W_mul(W1, W2 : word): word;              multiplication
  16.         W_div(W1, W2 : word): word;              division (W1/W2)
  17.         W_mod(W1, W2 : word): word;              modulus
  18.         W_and(W1, W2 : word): word;              bitwise logical and
  19.         W_shl(W1 : word, Shift : integer): word; logical leftshift
  20.         W_shr(W1 : word, Shift : integer): word; logical rightshift
  21.  
  22.         I_wrd(W1 : word): integer                word to integer conversion
  23.         W_int(I1 : integer): word                integer to word conversion
  24.  
  25.         W_cmp(W1 : word, Op : Relational_Operator, W2 : word): boolean;
  26.                                                  with Relational_Operator =
  27.                                                  (Eq, Gt, Lt, Ne, Ge, Le.)
  28.  
  29. }
  30.  
  31. FUNCTION W_not(W1 : word): word;
  32. BEGIN
  33.   InLine(
  34.   $8B/$86/W1/        { mov     ax,W1[bp] }
  35.   $F7/$D0/           { not     ax        }
  36.   $89/$46/$06        { mov     [bp+6],ax }
  37.   );
  38. END;
  39.  
  40. FUNCTION W_add(W1, W2 : word): word;
  41. BEGIN
  42.   InLine(
  43.   $8B/$86/W1/        { mov     ax,W1[bp] }
  44.   $03/$86/W2/        { add     ax,W2[bp] }
  45.   $89/$46/$08        { mov     [bp+8],ax }
  46.   );
  47. END;
  48.  
  49. FUNCTION W_sub(W1, W2 : word): word;
  50. BEGIN
  51.   InLine(
  52.   $8B/$86/W1/        { mov     ax,W1[bp] }
  53.   $2B/$86/W2/        { sub     ax,W2[bp] }
  54.   $89/$46/$08        { mov     [bp+8],ax }
  55.   );
  56. END;
  57.  
  58. FUNCTION W_or (W1, W2 : word): word;
  59. BEGIN
  60.   InLine(
  61.   $8B/$86/W1/        { mov     ax,W1[bp] }
  62.   $0B/$86/W2/        { or      ax,W2[bp] }
  63.   $89/$46/$08        { mov     [bp+8],ax }
  64.   );
  65. END;
  66.  
  67. FUNCTION W_xor(W1, W2 : word): word;
  68. BEGIN
  69.   InLine(
  70.   $8B/$86/W1/        { mov     ax,W1[bp] }
  71.   $33/$86/W2/        { xor     ax,W2[bp] }
  72.   $89/$46/$08        { mov     [bp+8],ax }
  73.   );
  74. END;
  75.  
  76. FUNCTION W_mul(W1, W2 : word): word;
  77. BEGIN
  78.   InLine(
  79.   $8B/$86/W1/        { mov     ax,W1[bp] }
  80.   $F7/$A6/W2/        { mul     W2[bp]    }
  81.   $89/$46/$08        { mov     [bp+8],ax }
  82.   );
  83. END;
  84.  
  85. FUNCTION W_div(W1, W2 : word): word;
  86. BEGIN
  87.   InLine(
  88.   $8B/$86/W1/        { mov     ax,W1[bp] }
  89.   $99/               { cwd               }
  90.   $F7/$B6/W2/        { div     W2[bp]    }
  91.   $89/$46/$08        { mov     [bp+8],ax }
  92.   );
  93. END;
  94.  
  95. FUNCTION W_mod(W1, W2 : word): word;
  96. BEGIN
  97.   InLine(
  98.   $8B/$86/W1/        { mov     ax,W1[bp] }
  99.   $99/               { cwd               }
  100.   $F7/$B6/W2/        { div     W2[bp]    }
  101.   $89/$56/$08        { mov     [bp+8],dx }
  102.   );
  103. END;
  104.  
  105. FUNCTION W_and(W1, W2 : word): word;
  106. BEGIN
  107.   InLine(
  108.   $8B/$86/W1/        { mov     ax,W1[bp] }
  109.   $23/$86/W2/        { and     ax,W2[bp] }
  110.   $89/$46/$08        { mov     [bp+8],ax }
  111.   );
  112. END;
  113.  
  114. FUNCTION W_shl(W1 : word; Shift : INTEGER): word;
  115. BEGIN
  116.   InLine(
  117.   $8B/$86/W1/        { mov     ax,W1[bp]    }
  118.   $8B/$8E/Shift/     { mov     cx,Shift[bp] }
  119.   $D3/$E0/           { shl     ax,cl        }
  120.   $89/$46/$08        { mov     [bp+8],ax    }
  121.   );
  122. END;
  123.  
  124. FUNCTION W_shr(W1 : word; Shift : INTEGER): word;
  125. BEGIN
  126.   InLine(
  127.   $8B/$86/W1/        { mov     ax,W1[bp]    }
  128.   $8B/$8E/Shift/     { mov     cx,Shift[bp] }
  129.   $D3/$E8/           { shr     ax,cl        }
  130.   $89/$46/$08        { mov     [bp+8],ax    }
  131.   );
  132. END;
  133.  
  134. FUNCTION I_wrd(W1 : word): INTEGER;
  135. BEGIN
  136.   InLine(
  137.   $8B/$86/W1/        { mov     ax,W1[bp] }
  138.   $89/$46/$06        { mov     [bp+6],ax }
  139.   );
  140. END;
  141.  
  142. FUNCTION W_int(I1 : INTEGER): word;
  143. BEGIN
  144.   InLine(
  145.   $8B/$86/I1/        { mov     ax,I1[bp] }
  146.   $89/$46/$06        { mov     [bp+6],ax }
  147.   );
  148. END;
  149.  
  150. FUNCTION W_cmp(W1 : word; Operator : Relational_Operator; W2 : word): BOOLEAN;
  151.   BEGIN
  152.     InLine(
  153.   $8B/$86/>W1        {  mov     ax,>W1[bp]}
  154.   /$8B/$96/>W2       {  mov     dx,>W2[bp]}
  155.   /$31/$C9           {  xor     cx,cx       ;clear msb}
  156.   /$31/$DB           {  xor     bx,bx       ;assume false}
  157.   /$8A/$4E/$06       {  mov     cl,[bp+6]   ;snarf the operator}
  158.   /$09/$C9           {  or      cx,cx       ;Eq?}
  159.   /$74/$16           {  je      Eq          ; yep}
  160.   /$80/$F9/$01       {  cmp     cl,1        ;Gt?}
  161.   /$74/$17           {  je      Gt          ; yep}
  162.   /$80/$F9/$02       {  cmp     cl,2        ;Lt?}
  163.   /$74/$18           {  je      Lt          ; yep}
  164.   /$80/$F9/$03       {  cmp     cl,3        ;Ne?}
  165.   /$74/$19           {  je      Ne          ; yep}
  166.   /$80/$F9/$04       {  cmp     cl,4        ;Ge?}
  167.   /$74/$1A           {  je      Ge          ; yep}
  168.   /$EB/$1E           {  jmp short Le        ; must be Le}
  169.                      
  170.                      {Eq:}
  171.   /$39/$D0           {  cmp     ax,dx}
  172.   /$75/$1F           {  jne     False}
  173.   /$EB/$1C           {  jmp short True}
  174.                      
  175.                      {Gt:}
  176.   /$39/$D0           {  cmp     ax,dx}
  177.   /$7E/$19           {  jle     False}
  178.   /$EB/$16           {  jmp short True}
  179.                      
  180.                      {Lt:}
  181.   /$39/$D0           {  cmp     ax,dx}
  182.   /$73/$13           {  jae     False}
  183.   /$EB/$10           {  jmp short True}
  184.                      
  185.                      {Ne:}
  186.   /$39/$D0           {  cmp     ax,dx}
  187.   /$74/$0D           {  je      False}
  188.   /$EB/$0A           {  jmp short True}
  189.                      
  190.                      {Ge:}
  191.   /$39/$D0           {  cmp     ax,dx}
  192.   /$72/$07           {  jb      False}
  193.   /$EB/$04           {  jmp short True}
  194.                      
  195.                      {Le:}
  196.   /$39/$D0           {  cmp     ax,dx}
  197.   /$77/$01           {  ja      False}
  198.                      
  199.                      {True:}
  200.   /$43               {  inc  bx         ;make it true}
  201.                      {False:            ;just stuff the 0}
  202.   /$88/$5E/$0A       {  mov  [bp+$0A],bl}
  203.                      {Exeunt:           ;and let Turbo do the rest}
  204. );
  205.   END;  {of W_cmp}
  206.